<?php defined('SYSPATH') or die('No direct access allowed.');

class Model_Specs_Camera extends Model_Specs_Abstract
{
    protected $_table_name = 'camera_specs';
    protected $_tmp_table_name = 'tmp_cameras';
    
    public static $_camera_types = array(
        0 => 'компактная фотокамера',
        1 => 'сверхтонкая фотокамера',
        
        2 => 'любительская зеркальная фотокамера',
        
        3 => 'профессиональная зеркальная фотокамера',
        
        4 => 'продвинутая зеркальная фотокамера',
        
        5 => 'цифровая фотокамера',     
        
        6 => 'фотокамера с суперзумом',
        
        7 => 'продвинутая фотокамера',
        
        8 => 'фотокамера с поддержкой сменных объективов',
    );
    public static $_extended_camera_types = array(
        0 => array(
            'forms' => array(
                'one'    => 'компактная фотокамера',
                'many'   => 'компактные фотокамеры',
                'many_genitive' => 'компактных фотокамер',
                'many_ablative' => 'компактными фотокамерами',   
            ), 
        ),
        1 => array(
            'forms' => array(
                'one'    => 'сверхтонкая фотокамера',
                'many'   => 'сверхтонкие фотокамеры',
                'many_genitive' => 'сверхтонких фотокамер', 
                'many_ablative' => 'сверхтонкими фотокамерами',
            ), 
        ),
        2 => array(
            'forms' => array(
                'one'    => 'любительская зеркальная фотокамера',
                'many'   => 'любительские зеркальные фотокамеры',
                'many_genitive' => 'любительских зеркальных фотокамер', 
                'many_ablative' => 'любительскими зеркальными фотокамерами', 
            ), 
        ),
        3 => array(
            'forms' => array(
                'one'    => 'профессиональная зеркальная фотокамера',
                'many'   => 'профессиональные зеркальные фотокамеры',
                'many_genitive' => 'профессиональных зеркальных фотокамер',
                'many_ablative' => 'профессиональными зеркальными фотокамерами',
            ), 
        ),
        4 => array(
            'forms' => array(
                'one'    => 'продвинутая зеркальная фотокамера',
                'many'   => 'продвинутые зеркальные фотокамеры',
                'many_genitive' => 'продвинутых зеркальных фотокамер',
                'many_ablative' => 'продвинутыми зеркальными фотокамерами',
            ), 
        ),
        5 => array(
            'forms' => array(
                'one'    => 'цифровая фотокамера',
                'many'   => 'цифровые фотокамеры',
                'many_genitive' => 'цифровых фотокамер',
                'many_ablative' => 'цифровыми фотокамерами',
            ), 
        ),
        6 => array(
            'forms' => array(
                'one'    => 'фотокамера с суперзумом',
                'many'   => 'фотокамеры с суперзумом',
                'many_genitive' => 'фотокамер с суперзумом', 
                'many_ablative' => 'фотокамерами с суперзумом',
            ), 
        ),
        7 => array(
            'forms' => array(
                'one'    => 'продвинутая фотокамера',
                'many'   => 'продвинутые фотокамеры',
                'many_genitive' => 'продвинутых фотокамер',
                'many_ablative' => 'продвинутыми фотокамерами',
            ), 
        ),
        8 => array(
            'forms' => array(
                'one'    => 'фотокамера с поддержкой сменных объективов',
                'many'   => 'фотокамеры с поддержкой сменных объективов',
                'many_genitive' => 'фотокамер с поддержкой сменных объективов',
                'many_ablative' => 'фотокамерами с поддержкой сменных объективов', 
            ), 
        ),   
    );
    public static $_matrix_types = array(
        0 => 'CCD',
        1 => 'CMOS',
        2 => 'BSI CMOS',
    );
    public static $_viewfinder_types = array(
        0 => 'нет',
        1 => 'оптический',
        2 => 'электронный',
        3 => 'зеркальный (TTL)',
    );
    public static $_flash_modes = array(
        0 => 'E-TTL',
        1 => 'E-TTL II',
        2 => 'D-TTL',
        3 => 'i-TTL',
        4 => 'P-TTL',
        5 => 'S-TTL',
        6 => 'ADI-TTL',
    );
    public static $_image_stabilizer_modes = array(
        0 => 'отсутствует',
        1 => 'цифровой',
        2 => 'оптический',
        3 => 'двойной',
    );
    public static $_body_material_modes = array(
        0 => 'пластик',
        1 => 'металл/пластик',
        2 => 'металл',
    );
    
    public static function get_sorted_camera_types()
    {
        $sort = array(
            0 => 4,
            1 => 5,
            2 => 0,
            3 => 2,
            4 => 3,
            5 => 8,
            6 => 6,
            7 => 1,
            8 => 7,
        );
        $result = array();
        foreach (self::$_camera_types as $key => $name) {
            $result[$sort[$key]] = array(
                'id'   => $key,
                'name' => $name,
            );    
        }
        ksort($result);
        return $result;   
    }
    public function get_stat()
    {
        if ($result = Cache::instance()->get('camera_stat')) {
            return $result;
        } 
        
        $result = array();
        $result['all'] = 0;
        $data = DB::select('camera_type', array('COUNT("*")', 'count'))
                    ->from('camera_specs')
                    ->group_by('camera_type')         
                    ->execute()
                    ->as_array();                   
        foreach ($data as $item) {
            $result[$item['camera_type']] = $item['count']; 
            $result['all'] += $item['count'];   
        }
        Cache::instance()->set('camera_stat', $result);
        return $result;       
    }
    
    public function get_winner(Model_Model $model1, Model_Model $model2)
    {
        $id = $model1->id;
        if ($model2->specs_score > $model1->specs_score) {
            $id = $model2->id;     
        }
        return ORM::factory('specs_camera', $id);
    }
    
    public function compare($model1, $model2, $competitors, $winner)
    {
        $result = array(
            'winner'  => null,              // Победитель
            /*'reasons' => array(             // Причины купить один из фотоаппаратов
                $model1->id => array(),
                $model2->id => array(),       
            ),     */
            'differences' => array(         // Различия (перимущества)
                $model1->id => array(),
                $model2->id => array(),
            ),
            'similarities' => array(),      // Схожества
            'competitors'  => array(), 
        );
        if ($model1 instanceof Model_Model) {
            $specs1 = ORM::factory('specs_camera', $model1->id);    
        } else if ($model1 instanceof Model_Specs_Camera) {
            $specs1 = clone $model1;     
        } else {
            throw new Model_Exception('Неизвестный тип модели №1');
        }
        
        if ($model2 instanceof Model_Model) {
            $specs2 = ORM::factory('specs_camera', $model2->id);    
        } else if ($model1 instanceof Model_Specs_Camera) {
            $specs2 = clone $model2;     
        } else {
            throw new Model_Exception('Неизвестный тип модели №2');
        }
        
        $template = ORM::factory('specs_camera')->get_available_specs(true);
        
        $result['winner'] = $winner->id;
            
        // TODO reasons Из списка различий, как-то выбрать основное - 2-6 шт. 
        
        // differences, similarities 
        foreach ($template as $key => $item) {
            if (!isset($item['comparable']) || !$item['comparable']) {
                continue;
            }
            $value1 = $specs1->__get($key);
            $value2 = $specs2->__get($key);
            if (!is_null($value1) && !is_null($value2)) {
                // Сравним значения в зависимости от флага reverse характеристик
                if ($value1 != $value2) {
                    if (isset($item['reverse']) && $item['reverse']) {  // Реверсивно, чем больше - тем хуже
                        if ($value1 > $value2) {    // У model2 лучше 
                            $result['differences'][$model2->id][] = $key;    
                        } else {
                            $result['differences'][$model1->id][] = $key;
                        }    
                    } else {
                        if ($value1 > $value2) {    // У model1 лучше 
                            $result['differences'][$model1->id][] = $key;    
                        } else {
                            $result['differences'][$model2->id][] = $key;
                        }   
                    }   
                } else {
                    $result['similarities'][] = $key;
                }        
            } else if (!is_null($value1)) {     // У model2 хар-ка отсутствует (кроме случая с boolean в хар-ках)
                $result['differences'][$model1->id][] = $key;   
            } else if (!is_null($value2)) {
                $result['differences'][$model2->id][] = $key;   
            }      
        }
        
        // competitors
        if (count($competitors)) {
            $ids = array();
            foreach ($competitors as $competitor) {
                $ids[] = $competitor->id;    
            }
            $competitor_specs = ORM::factory('specs_camera')
                                    ->where('id', 'IN', $ids)
                                    ->find_all();
            foreach ($competitor_specs as $competitor_spec) {
                // TODO победитель!! на место $specs1
                $result['competitors'][$competitor_spec->id] = $this->short_compare($competitor_spec, $winner);
            }   
        }
        
        return $result;
    }
    
    // Список достоинств и недостатков $model1 по сравнению с $model2
    public function short_compare($model1, $model2, $limit = 3)
    { 
        $result = array(
            'advantages'    => array(),
            'disadvantages' => array(),
        );
           
        if ($model1 instanceof Model_Model) {
            $specs1 = ORM::factory('specs_camera', $model1->id);    
        } else if ($model1 instanceof Model_Specs_Camera) {
            $specs1 = clone $model1;     
        } else {
            throw new Model_Exception('Неизвестный тип модели №1');
        }
        
        if ($model2 instanceof Model_Model) {
            $specs2 = ORM::factory('specs_camera', $model2->id);    
        } else if ($model1 instanceof Model_Specs_Camera) {
            $specs2 = clone $model2;     
        } else {
            throw new Model_Exception('Неизвестный тип модели №2');
        }
        
        $template = ORM::factory('specs_camera')->get_available_specs(true);
        
        foreach ($template as $key => $item) {
            if (!isset($item['comparable']) || !$item['comparable']) {
                continue;
            }
            $value1 = $specs1->__get($key);
            $value2 = $specs2->__get($key);
            if (!is_null($value1) && !is_null($value2)) {
                // Сравним значения в зависимости от флага reverse характеристик
                if ($value1 != $value2) {
                    if (isset($item['reverse']) && $item['reverse']) {  // Реверсивно, чем больше - тем хуже
                        if ($value1 > $value2) { 
                            $result['disadvantages'][] = $key;    
                        } else {
                            $result['advantages'][] = $key;
                        }    
                    } else {
                        if ($value1 > $value2) {    // У model1 лучше 
                            $result['advantages'][] = $key;    
                        } else {
                            $result['disadvantages'][] = $key;
                        }   
                    }   
                }        
            } else if (!is_null($value1)) {     // У model2 хар-ка отсутствует (кроме случая с boolean в хар-ках)
                $result['advantages'][] = $key;   
            } else if (!is_null($value2)) {
                $result['disadvantages'][] = $key;   
            }      
        }
        
        $result['advantages']    = array_slice($result['advantages'], 0, $limit);
        $result['disadvantages'] = array_slice($result['disadvantages'], 0, $limit);      
        return $result;
    }
    
    // Список достоинств и недостатков $model по сравнению с камерами этого же типа
    public function compare_with_same_type($model, $specs, $limit = null)
    { 
        $result = array(
            'advantages'    => array(),
            'disadvantages' => array(),
        );
        
        $compare_data = ORM::factory('specs_camera')->get_medium_compare_data($specs);      
        $template     = ORM::factory('specs_camera')->get_available_specs(true);
        
        foreach ($template as $key => $item) {
            if (!isset($item['comparable']) || !$item['comparable']) {
                continue;
            }
            $value1 = $specs->__get($key);
            $value2 = isset($compare_data[$key]) ? $compare_data[$key] : null;
            if (!is_null($value1) && !is_null($value2)) {
                // Сравним значения в зависимости от флага reverse характеристик
                if ($value1 != $value2) {
                    if (isset($item['reverse']) && $item['reverse']) {  // Реверсивно, чем больше - тем хуже
                        if ($value1 > $value2) { 
                            $result['disadvantages'][] = $key;    
                        } else {
                            $result['advantages'][] = $key;
                        }    
                    } else {
                        if ($value1 > $value2) {    // У model1 лучше 
                            $result['advantages'][] = $key;    
                        } else {
                            $result['disadvantages'][] = $key;
                        }   
                    }   
                }        
            } else if (!is_null($value1)) {
                $result['advantages'][] = $key;   
            } else if (!is_null($value2)) {
                $result['disadvantages'][] = $key;   
            }      
        } 
        if ($limit) {   
            $result['advantages']    = array_slice($result['advantages'], 0, $limit);
            $result['disadvantages'] = array_slice($result['disadvantages'], 0, $limit);
        }
        return $result;
    }
    
    public function get_specs_full_data_for_main($model)
    { 
        $result          = array();  
        $available_specs = array('matrix_type', 'physical_size', 'total_pixels', 'lcd_size',
                    'lcd_resolution', 'sensitivity', 'battery_capacity');
        $specs           = $this->get_specs_full_data($model, true);
        foreach ($specs as $key => $item) {
            if (in_array($key, $available_specs)) {
                $result[$key] = $item;   
            }    
        }
        return $result;     
    }
    
    public function get_specs_full_data($model, $flat = false)
    {
        // TODO cache
        if ($model instanceof Model_Model) {
            $_specs = ORM::factory('specs_camera', $model->id);    
        } else if ($model instanceof Model_Specs_Camera) {
            $_specs = $model;    
        } else {
            throw new Model_Exception('Неверный тип');
        }
        
        $specs        = array();
        $template     = ORM::factory('specs_camera')->get_available_specs();
        $compare_data = ORM::factory('specs_camera')->get_compare_data($_specs);
        
        foreach ($template as $group_key => $group) {
            $isset_data = false;
            $items      = array();
            foreach ($group['items'] as $key => $item) {
                $value = $_specs->__get($key);
                if (!is_null($value)) {
                    $isset_data = true;
                    $items[$key] = $_specs->get_spec_data($key, $item, $compare_data);        
                }    
            }   
            if ($isset_data) {
                if ($flat) {
                    $specs = array_merge($specs, $items);       
                } else {
                    $specs[$group_key] = array(
                        'name'  => $group['name'],
                        'items' => $items,
                    );
                }        
            } 
        } 
        return $specs;
    }
    
    public function get_compare_data($spec)
    {
        if ($result = Cache::instance()->get('compare_data_'.$spec->camera_type)) {
            return $result;
        } 
        
        $minmax          = ORM::factory('specs_camera')->get_minmax_compare_data($spec);
        $absolute_minmax = ORM::factory('specs_camera')->get_minmax_compare_data();
        
        $result = array();
        $data = $this->_get_compare_data($spec);
        
        foreach ($data as $key => &$items) {
            foreach ($items as &$item) {
                $item['min']          = $minmax[$key]['min'];
                $item['max']          = $minmax[$key]['max'];
                $item['absolute_min'] = $absolute_minmax[$key]['min'];
                $item['absolute_max'] = $absolute_minmax[$key]['max'];
            }    
        }
        Cache::instance()->set('compare_data_'.$spec->camera_type, $data);
        return $data;   
    }
    
    protected function _get_compare_data($spec = null)
    {
        $camera_type = $spec ? $spec->camera_type : 'all'; 
        if ($result = Cache::instance()->get('_compare_data_'.$camera_type)) {
            return $result;
        }
        
        $result = array();
        $data = DB::select()
                    ->from('camera_specs_compare');
        if ($spec) {
            $data->where('camera_type', '=', $spec->camera_type);    
        }
        $data = $data->execute()
                     ->as_array();
             
        foreach ($data as $item) {
            $result[$item['spec']][] = $item;    
        }
        Cache::instance()->set('_compare_data_'.$camera_type, $result);
        return $result;   
    }
    
    public function get_medium_compare_data($specs)
    {
        $result = array();
        $compare_data = $this->get_compare_data($specs);
        foreach ($compare_data as $key => $items) {
            $medium = 0;
            $count  = 0;
            foreach ($items as $item) {
                $medium += $item['value']*$item['count_same'];
                $count  += $item['count_same'];    
            } 
            if ($count == 0) {
                $medium = 0;    
            } else {
                $medium /= $count;
                $medium = round($medium);   
            } 
            $result[$key] = $medium;  
        } 
        return $result;   
    }
    
    public function get_minmax_compare_data($specs = null)
    {
        $result = array();
        $compare_data = $this->_get_compare_data($specs);
        foreach ($compare_data as $key => $items) {
            $min = $max = 0;
            $first = true;
            foreach ($items as $item) {
                if ($first) {
                    $min = $max = $item['value'];
                    $first = false;
                    continue;
                }
                if ($item['value'] < $min) {
                    $min = $item['value'];
                }
                if ($item['value'] > $max) {
                    $max = $item['value']; 
                }    
            }  
            $result[$key] = array(
                'min' => $min,
                'max' => $max,
            );  
        } 
        return $result;   
    }
    
    public function order_available_specs(&$specs)
    {
        return usort($specs, array(__CLASS__, '_compare_available_specs'));    
    }
    
    protected static function _compare_available_specs($a, $b) {
        if (isset($a['weight']) && isset($b['weight'])) {
            return $a['weight'] <= $b['weight'];
        } else if (isset($a['weight'])) {
            return false;    
        }
        return true;    
    }
    
    public function get_available_specs($flat = false, $order = true)
    {
        $result = array(
            'sensor'    => array(
                'name'  => 'Матрица',
                'items' => array(
                    'matrix_type'      => array('name' => 'Тип',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Тип матрицы качественнее',
                                                    'normal_form'    => 'Тип матрицы',
                                                    'disadvantage_form' => 'Тип матрицы хуже',
                                                    'weight'      => 75,),
                    'physical_size'    => array('name' => 'Размер',
                                                    'suffix'        => ' мм',
                                                    'visible_field' => true,
                                                    'comparable' => true,
                                                    'advantage_form' => 'Размер матрицы больше',
                                                    'normal_form'    => 'Размер матрицы',
                                                    'disadvantage_form' => 'Размер матрицы меньше',
                                                    'weight'      => 75,),
                    'crop_factor'      => array('name' => 'Кроп-фактор',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Кроп-фактор матрицы меньше',
                                                    'normal_form'    => 'Кроп-фактор матрицы',
                                                    'disadvantage_form' => 'Кроп-фактор матрицы больше',
                                                    'weight'      => 75,
                                                    'reverse' => true,),
                    'total_pixels'     => array('name' => 'Пикселов',
                                                    'suffix' => ' млн',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Число пикселов больше',
                                                    'normal_form'    => 'Число пикселов',
                                                    'disadvantage_form' => 'Число пикселов меньше',),
                    'effective_pixels' => array('name' => 'Эффективных пикселов', 
                                                    'suffix' => ' млн',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Число эффективных пикселов больше',
                                                    'normal_form'    => 'Число эффективных пикселов',
                                                    'disadvantage_form' => 'Число эффективных пикселов меньше',
                                                    'weight'      => 50,),
                    'max_resolution'   => array('name' => 'Разрешение',
                                                    'visible_field' => true,
                                                    'comparable' => true,
                                                    'advantage_form' => 'Максимальное разрешение фотоснимков лучше',
                                                    'normal_form'    => 'Максимальное разрешение фотоснимков',
                                                    'disadvantage_form' => 'Максимальное разрешение фотоснимков меньше',
                                                    'weight'      => 37.5,),
                    'color_depth'      => array('name' => 'Глубина цвета',
                                                    'suffix' => ' бит',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Лучше глубина цвета матрицы',
                                                    'normal_form'    => 'Глубина цвета матрицы',
                                                    'disadvantage_form' => 'Хуже глубина цвета матрицы', 
                                                    'weight'      => 25,),
                    'sensitivity'      => array('name' => 'Чувствительность',       // TODO max min
                                                    'suffix'        => ' ISO',
                                                    'visible_field' => true,
                                                    'comparable' => true,
                                                    'advantage_form' => 'Чувствительность матрицы лучше',
                                                    'normal_form'    => 'Чувствительность матрицы',
                                                    'disadvantage_form' => 'Чувствительность матрицы хуже',),
                    'boost_sensitivity' => array('name' => 'Макс. чувствительность',
                                                    'suffix' => ' ISO',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Макс. чувствительность матрицы больше',
                                                    'normal_form'    => 'Макс. чувствительность матрицы',
                                                    'disadvantage_form' => 'Макс. чувствительность матрицы меньше',),
                    'sensor_cleaning'  => array('name' => 'Очистка матрицы',
                                                    'boolean' => true,
                                                    'comparable' => true,
                                                    'advantage_form' => 'Есть очистка матрицы',
                                                    'normal_form'    => 'Очистка матрицы',
                                                    'disadvantage_form' => 'Нет очистки матрицы',),
                ),
            ),
            'lens'      => array(
                'name'  => 'Объектив',
                'items' => array(
                    'lens_name'                    => array('name' => 'Название',),
                    'min_focal_length'             => array('name' => 'Мин. фокусное расстояние', 
                                                                'suffix' => ' мм',
                                                                'comparable' => true,
                                                                'advantage_form' => 'Мин. фокусное расстояние объектива меньше',
                                                                'normal_form'    => 'Мин. фокусное расстояние объектива',
                                                                'disadvantage_form' => 'Мин. фокусное расстояние объектива больше',
                                                                'weight'      => 37.5,
                                                                'reverse' => true,),
                    'max_focal_length'             => array('name' => 'Макс. фокусное расстояние',
                                                                'suffix' => ' мм',
                                                                'comparable' => true,
                                                                'advantage_form' => 'Больше макс. фокусное расстояние объектива',
                                                                'normal_form'    => 'Макс. фокусное расстояние объектива',
                                                                'disadvantage_form' => 'Меньше макс. фокусное расстояние объектива',
                                                                'weight'      => 37.5,),
                    'optical_zoom'                 => array('name' => 'Оптический Zoom',
                                                                'suffix' => 'x',
                                                                'comparable' => true,
                                                                'advantage_form' => 'Оптический Zoom больше',
                                                                'normal_form'    => 'Оптический Zoom',
                                                                'disadvantage_form' => 'Оптический Zoom меньше',
                                                                'weight'      => 25,),
                    'min_diaphragm'                => array('name' => 'Мин. диафрагма',
                                                                'prefix' => 'F',
                                                                'comparable' => true,
                                                                'advantage_form' => 'Меньше мин. диафрагма объектива',
                                                                'normal_form'    => 'Мин. диафрагма объектива',
                                                                'disadvantage_form' => 'Больше мин. диафрагма объектива',
                                                                'weight'      => 25,
                                                                'reverse' => true,),
                    'max_diaphragm'                => array('name' => 'Макс. диафрагма',
                                                                'prefix' => 'F',
                                                                'comparable' => true,
                                                                'advantage_form' => 'Макс. диафрагма объектива больше',
                                                                'normal_form'    => 'Макс. диафрагма объектива',
                                                                'disadvantage_form' => 'Макс. диафрагма объектива меньше',
                                                                'weight'      => 25,),
                    /*'optical_elements_count'       => array('name' => 'Оптических элементов',
                                                                'comparable' => true,),
                    'optical_element_groups_count' => array('name' => 'Групп оптических элементов',
                                                                'comparable' => true,),*/
                    'aspherical_lens'              => array('name' => 'Асферические линзы',
                                                                'boolean' => true,
                                                                'comparable' => true,
                                                                'advantage_form' => 'В объективе использованы асферические линзы',
                                                                'normal_form'    => 'Асферические линзы в объективе',
                                                                'disadvantage_form' => 'В объективе не использованы асферические линзы',),
                    'low_dispersion_lenses'        => array('name' => 'Низкодисперсные линзы',
                                                                'boolean' => true,
                                                                'comparable' => true,
                                                                'advantage_form' => 'В объективе использованы низкодисперсные линзы',
                                                                'normal_form'    => 'Низкодисперсные линзы в объективе',
                                                                'disadvantage_form' => 'В объективе не использованы низкодисперсные линзы',),
                ),
            ),
            'screen'      => array(
                'name'  => 'Экран',
                'items' => array(
                    'lcd_size'         => array('name' => 'Размер',
                                                    'suffix' => ' дюйма',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Размер экрана больше',
                                                    'normal_form'    => 'Размер экрана',
                                                    'disadvantage_form' => 'Размер экрана меньше',
                                                    'weight'      => 37.5,),
                    'lcd_resolution'   => array('name' => 'Разрешение',
                                                    'suffix' => ' пикселов',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Разрешение экрана больше',
                                                    'normal_form'    => 'Разрешение экрана',
                                                    'disadvantage_form' => 'Разрешение экрана меньше',
                                                    'weight'      => 25,), 
                    'lcd_touch_screen' => array('name' => 'Сенсорный',
                                                    'boolean' => true,
                                                    'comparable' => true,
                                                    'advantage_form' => 'Экран сенсорный',
                                                    'normal_form'    => 'Сенсорный экран',
                                                    'disadvantage_form' => 'Экран не сенсорный',
                                                    'weight'      => 12.5,), 
                    'lcd_flips_out'    => array('name' => 'Поворотный',
                                                    'boolean' => true,
                                                    'comparable' => true,
                                                    'advantage_form' => 'Экран поворотный',
                                                    'normal_form'    => 'Поворотный экран',
                                                    'disadvantage_form' => 'Экран не поворотный',
                                                    'weight'      => 12.5,), 
                ),
            ),
            'size-body'      => array(
                'name'  => 'Размеры и корпус',
                'items' => array(
                    'size'          => array('name' => 'Размер',      // TODO width height depth
                                                'suffix' => ' мм',
                                                'visible_field' => true,
                                                'comparable' => true,
                                                'advantage_form' => 'Компактнее',
                                                'normal_form'    => 'Размер',
                                                'disadvantage_form' => 'Размеры больше',
                                                'weight'      => 12.5,
                                                'reverse' => true,),
                    'size_wout_lens' => array('name' => 'Размер',       // ...
                                                'suffix' => ' мм',
                                                'visible_field' => true,
                                                'comparable' => true,
                                                'advantage_form' => 'Компактнее',
                                                'normal_form'    => 'Размер',
                                                'disadvantage_form' => 'Размеры больше',
                                                'weight'      => 12.5,
                                                'reverse' => true,),
                    'weight_brutto' => array('name' => 'Вес',
                                                'suffix' => ' г',
                                                'comparable' => true,
                                                'advantage_form' => 'Легче',
                                                'normal_form'    => 'Вес',
                                                'disadvantage_form' => 'Тяжелее',
                                                'weight'      => 12.5,
                                                'reverse' => true,), 
                    'weight_netto'  => array('name' => 'Вес (без питания)',
                                                'suffix' => ' г',
                                                'comparable' => true,
                                                'advantage_form' => 'Легче',
                                                'normal_form'    => 'Вес',
                                                'disadvantage_form' => 'Тяжелее',
                                                'reverse' => true,),
                    'body_material' => array('name' => 'Материал корпуса',
                                                'comparable' => true,
                                                'advantage_form' => 'Корпус сделан из более качественных материалов',
                                                'normal_form'    => 'Материал корпуса',
                                                'disadvantage_form' => 'Корпус сделан из менее качественных материалов',
                                                'weight'      => 12.5,),
                    'waterproof_case' => array('name' => 'Влагонепроницаемый корпус',
                                                'boolean' => true, 
                                                'comparable' => true,
                                                'advantage_form' => 'Влагонепроницаемый корпус',
                                                'normal_form'    => 'Влагонепроницаемый корпус',
                                                'disadvantage_form' => 'Корпус не влагонепроницаемый',),
                    'change_lenses'   => array('name' => 'Сменный объектив',
                                                'boolean' => true,
                                                'comparable' => true,
                                                'advantage_form' => 'Возможность сменить объектив',
                                                'normal_form'    => 'Сменный объектив',
                                                'disadvantage_form' => 'Нет возможности сменить объектив',), 
                    
                      
                ),
            ),
            'viewfinder'      => array(
                'name'  => 'Видоискатель',
                'items' => array(
                    'viewfinder'       => array('name' => 'Тип',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Тип видоискателя лучше',
                                                    'normal_form'    => 'Тип видоискателя',
                                                    'disadvantage_form' => 'Тип видоискателя хуже',
                                                    'weight'      => 25,),  
                    'viewfinder_sight' => array('name' => 'Поле зрения',
                                                    'suffix' => '%',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Поле зрения виоискателя больше',
                                                    'normal_form'    => 'Поле зрения виоискателя',
                                                    'disadvantage_form' => 'Поле зрения виоискателя меньше',),      
                ),
            ),
            'video'      => array(
                'name'  => 'Запись видео',
                'items' => array(
                    /*'video_recording'        => array('name' => 'Запись видео',
                                                        'boolean' => true,
                                                        'comparable' => true,), */ 
                    'video_recording_format' => array('name' => 'Формат',), 
                    'video_codecs'           => array('name' => 'Видеокодеки',),
                    'max_video_resolution'   => array('name' => 'Макс. разрешение',
                                                        'visible_field' => true,
                                                        'comparable' => true,
                                                        'advantage_form' => 'Макс. разрешение видео больше',
                                                        'normal_form'    => 'Макс. разрешение видео',
                                                        'disadvantage_form' => 'Макс. разрешение видео меньше',), 
                    'max_video_frame_rate'   => array('name' => 'Макс. частота кадров',
                                                        'comparable' => true,
                                                        'advantage_form' => 'Макс. частота кадров при записи видео больше',
                                                        'normal_form'    => 'Макс. частота кадров при записи видео',
                                                        'disadvantage_form' => 'Макс. частота кадров при записи видео меньше',),
                    'max_hd_video_1280_720'  => array('name' => 'Макс. частота кадров при разрешении 1280x720',
                                                        'suffix'      => ' кадров/с',
                                                        'comparable' => true,
                                                        'advantage_form' => 'Макс. частота кадров при записи видео 1280x720 больше',
                                                        'normal_form'    => 'Макс. частота кадров при записи видео 1280x720',
                                                        'disadvantage_form' => 'Макс. частота кадров при записи видео 1280x720 меньше',),
                    'max_hd_video_1920_1080' => array('name' => 'Макс. частота кадров при разрешении 1920x1080',
                                                        'suffix'      => ' кадров/с',
                                                        'comparable' => true,
                                                        'advantage_form' => 'Макс. частота кадров при записи видео 1920x1080 больше',
                                                        'normal_form'    => 'Макс. частота кадров при записи видео 1920x1080',
                                                        'disadvantage_form' => 'Макс. частота кадров при записи видео 1920x1080 меньше',),
                    'duration_video_recording' => array('name' => 'Время записи',),                                    
                    'video_electronic_stabilization' => array('name' => 'Электронная стабилизация',
                                                        'boolean' => true,
                                                        'comparable' => true,
                                                        'advantage_form' => 'Есть электронная стабилизация при записи видео',
                                                        'normal_form'    => 'Электронная стабилизация при записи видео',
                                                        'disadvantage_form' => 'Нет электронной стабилизации при записи видео',),
                    'video_optical_zoom'     => array('name' => 'Оптический Zoom',
                                                        'boolean' => true,
                                                        'comparable' => true,
                                                        'advantage_form' => 'Больше оптический Zoom при записи видео',
                                                        'normal_form'    => 'Оптический Zoom при записи видео',
                                                        'disadvantage_form' => 'Меньше оптический Zoom при записи видео',),                          
                ),
            ),
            'features'      => array(
                'name'  => 'Функционал',
                'items' => array(
                    'image_stabilizer' => array('name' => 'Стабилизатор изображения',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Стабилизатор изображения лучше',
                                                    'normal_form'    => 'Стабилизатор изображения',
                                                    'disadvantage_form' => 'Стабилизатор изображения хуже', 
                                                    'weight'      => 25,),
                    'hdr_support'      => array('name' => 'Поддержка HDR',
                                                    'boolean' => true,
                                                    'comparable' => true,
                                                    'advantage_form' => 'Есть поддержка HDR',
                                                    'normal_form'    => 'Поддержка HDR',
                                                    'disadvantage_form' => 'Нет поддержки HDR',
                                                    'weight'      => 12.5,),
                    'gps'              => array('name' => 'GPS',
                                                    'boolean' => true,
                                                    'comparable' => true,
                                                    'advantage_form' => 'Имеется GPS',
                                                    'normal_form'    => 'GPS',
                                                    'disadvantage_form' => 'Нет GPS',),
                                                    
                                                                                                                                                            
                ),
            ),
            'performance'      => array(
                'name'  => 'Производительность',
                'items' => array(
                    'shooting_speed'        => array('name' => 'Скорость съемки',
                                                        'suffix'      => ' кадров/с',
                                                        'comparable' => true,
                                                        'advantage_form' => 'Скорость съемки выше',
                                                        'normal_form'    => 'Скорость съемки',
                                                        'disadvantage_form' => 'Скорость съемки меньше',
                                                        'weight'      => 25,),
                    'max_set_shots_jpeg'    => array('name' => 'Макс. серия снимков для JPEG',
                                                        'comparable' => true,
                                                        'advantage_form' => 'Макс. серия снимков для JPEG больше',
                                                        'normal_form'    => 'Макс. серия снимков для JPEG',
                                                        'disadvantage_form' => 'Макс. серия снимков для JPEG меньше',), 
                    'max_set_shots_raw'     => array('name' => 'Макс. серия снимков для RAW',
                                                        'comparable' => true,
                                                        'advantage_form' => 'Макс. серия снимков для RAW больше',
                                                        'normal_form'    => 'Макс. серия снимков для RAW',
                                                        'disadvantage_form' => 'Макс. серия снимков для RAW меньше',),    
                    'battery_capacity'      => array('name' => 'Емкость аккумулятора',
                                                        'suffix'      => ' фотографий',
                                                        'comparable' => true,
                                                        'advantage_form' => 'Емкость аккумулятора выше',
                                                        'normal_form'    => 'Емкость аккумулятора',
                                                        'disadvantage_form' => 'Емкость аккумулятора меньше',
                                                        'weight'      => 50,),                                                          
                ),
            ),   
            'focus'      => array(
                'name'  => 'Фокусировка',
                'items' => array(
                    'af_assist'      => array('name' => 'Подсветка автофокуса',
                                                            'boolean' => true,
                                                            'comparable' => true,
                                                            'advantage_form' => 'Есть подсветка автофокуса',
                                                            'normal_form'    => 'Подсветка автофокуса',
                                                            'disadvantage_form' => 'Нет подсветки автофокуса',),
                    'manual_focus'   => array('name' => 'Ручная фокусировка',
                                                            'boolean' => true,
                                                            'comparable' => true,
                                                            'advantage_form' => 'Возможность ручной фокусировки',
                                                            'normal_form'    => 'Ручная фокусировка',
                                                            'disadvantage_form' => 'Нет возможности ручной фокусировки',),
                    'af_adjustment'  => array('name' => 'Корректировка автофокуса',
                                                            'boolean' => true,
                                                            'comparable' => true,
                                                            'advantage_form' => 'Есть корректировка автофокуса',
                                                            'normal_form'    => 'Корректировка автофокуса',
                                                            'disadvantage_form' => 'Нет корректировки автофокуса',),
                    'face_focus'     => array('name' => 'Фокусировка по лицу',
                                                            'boolean' => true,
                                                            'comparable' => true,
                                                            'advantage_form' => 'Имеется фокусировка по лицу',
                                                            'normal_form'    => 'Фокусировка по лицу',
                                                            'disadvantage_form' => 'Нет фокусировки по лицу',),
                    'min_shooting_distance' => array('name' => 'Мин. расстояние съемки',
                                                            'suffix'      => ' м',
                                                            'comparable' => true,
                                                            'advantage_form' => 'Меньше мин. расстояние съемки',
                                                            'normal_form'    => 'Мин. расстояние съемки',
                                                            'disadvantage_form' => 'Больше мин. расстояние съемки',
                                                            'reverse' => true,),                                                        
                ),
            ),
            'flash'      => array(
                'name'  => 'Вспышка',
                'items' => array(
                    'max_flash_distance'      => array('name' => 'Макс. расстояние действия',
                                                            'suffix'      => ' м',
                                                            'comparable' => true,
                                                            'advantage_form' => 'Макс. расстояние действия вспышки больше',
                                                            'normal_form'    => 'Макс. расстояние действия вспышки',
                                                            'disadvantage_form' => 'Макс. расстояние действия вспышки меньше',),
                    'flash_mode'              => array('name' => 'Режим',),  
                    'flash_chock'             => array('name' => 'Башмак',
                                                            'boolean' => true,
                                                            'comparable' => true,
                                                            'advantage_form' => 'Есть башмак для вспышки',
                                                            'normal_form'    => 'Башмак для вспышки',
                                                            'disadvantage_form' => 'Нет башмака для вспышки',),
                    'flash_bracketing'        => array('name' => 'Брекетинг',
                                                            'boolean' => true,
                                                            'comparable' => true,
                                                            'advantage_form' => 'Брекетинг вспышки',
                                                            'normal_form'    => 'Брекетинг вспышки',
                                                            'disadvantage_form' => 'Нет брекетинга вспышки',),
                    'flash_red_eye_reduction' => array('name' => 'Подавление эффекта красных глаз',
                                                            'boolean' => true,
                                                            'comparable' => true,
                                                            'advantage_form' => 'Подавление эффекта красных глаз',
                                                            'normal_form'    => 'Подавление эффекта красных глаз',
                                                            'disadvantage_form' => 'Нет подавления эффекта красных глаз',),
                    'flash_synccontact'       => array('name' => 'Синхроконтакт',
                                                            'boolean' => true,
                                                            'comparable' => true,
                                                            'advantage_form' => 'Синхроконтакт для подключения вспышки',
                                                            'normal_form'    => 'Синхроконтакт для подключения вспышки',
                                                            'disadvantage_form' => 'Нет синхроконтакта для подключения вспышки',),                                      
                                                                           
                ),
            ),
            'storage'      => array(
                'name'  => 'Память',
                'items' => array(
                    'card_type'       => array('name' => 'Тип карт памяти',), 
                    'builtin_memory'  => array('name' => 'Встроенная память',
                                                    'suffix'      => ' Мб',
                                                    'comparable' => true,
                                                    'advantage_form' => 'Больший объем встроенной памяти',
                                                    'normal_form'    => 'Объем встроенной памяти',
                                                    'disadvantage_form' => 'Меньший объем встроенной памяти',), 
                    'image_formats'   => array('name' => 'Тип карт памяти',),                                                                                                          
                ),
            ),
            
            
        );
        
        if ($flat) {
            $flat_result = array();
            foreach ($result as $group_key => $group) {
                foreach ($group['items'] as $key => $item) {
                    $flat_result[$key] = $item;        
                }   
            }
            if ($order) {
                foreach ($flat_result as $key => &$value) {
                    $value['key'] = $key;    
                }
                $this->order_available_specs($flat_result);
                $result = array();
                foreach ($flat_result as $value) { 
                    $result[$value['key']] = $value;
                    unset($result[$value['key']]['key']);   
                } 
                return $result;   
            }
            return $flat_result;        
        }
        return $result;
    }
    
    protected function _get_matrix_type_value($rules)
    {
        return self::$_matrix_types[$this->matrix_type];   
    }
    
    protected function _get_physical_size_value($rules)
    {
        $value = $this->physical_size_visible;
        if (strstr($value, 'x') !== false) {    // на конце значения в мм
            $value .= $rules['suffix'];    
        }
        return $value;   
    }
    
    protected function _get_viewfinder_value($rules)
    {
        return self::$_viewfinder_types[$this->viewfinder];   
    }
    
    protected function _get_flash_mode_value($rules)
    {
        return self::$_flash_modes[$this->flash_mode];   
    }
    
    protected function _get_image_stabilizer_value($rules)
    {
        return self::$_image_stabilizer_modes[$this->image_stabilizer];  
    }
    
    protected function _get_body_material_value($rules)
    {
        return self::$_body_material_modes[$this->body_material]; 
    }
    
    public function process_compare_data()
    {
        $_specs = ORM::factory('specs_camera')->get_available_specs();
        $specs = array();
        foreach ($_specs as $group) {
            $specs = array_merge($specs, $group['items']);    
        }
        
        $cameras = DB::select()
                ->from('camera_specs')
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {
            foreach ($specs as $key => $spec) {
                if (isset($spec['comparable']) && $spec['comparable']) {
                    $camera_type = $camera['camera_type'];
                    if (is_null($camera_type)) {
                        continue;
                    }
                    $value = $camera[$key];
                    if (is_null($value)) {
                        continue;    
                    }
                    
                    try {
                        DB::insert('camera_specs_compare', array('camera_type', 'spec', 'value'))
                                ->values(array($camera_type, $key, $value))->execute();       
                    } catch (Database_Exception $e) {
                        if (strstr($e->getMessage(), 'Duplicate entry') !== false) {
                            continue;    
                        }
                        die($e->getMessage());
                    } 
                    
                    $better_symbol = '>';
                    $worse_symbol  = '<';
                    if (isset($spec['reverse']) && $spec['reverse']) {
                        $better_symbol = '<';
                        $worse_symbol  = '>';  
                    }
                    
                    $data = DB::select(DB::expr('COUNT(*)'))
                                    ->from('camera_specs')
                                    ->where($key, 'IS NOT', NULL)
                                    ->and_where('camera_type', '=', $camera_type)
                                    ->and_where($key, $better_symbol, $value)
                                    ->execute()
                                    ->as_array();
                    $better = $data[0]['COUNT(*)']; 
                        
                    $data = DB::select(DB::expr('COUNT(*)'))
                                    ->from('camera_specs')
                                    ->where($key, 'IS NOT', NULL)
                                    ->and_where('camera_type', '=', $camera_type)
                                    ->and_where($key, $worse_symbol, $value)
                                    ->execute()
                                    ->as_array();
                    $worse = $data[0]['COUNT(*)'];
                        
                    $data = DB::select(DB::expr('COUNT(*)'))
                                    ->from('camera_specs')
                                    ->where($key, 'IS NOT', NULL)
                                    ->and_where('camera_type', '=', $camera_type)
                                    ->and_where($key, '=', $value)
                                    ->and_where('id', '!=', $camera['id'])
                                    ->execute()
                                    ->as_array();
                    $same = $data[0]['COUNT(*)'];
                    
                    // ---
                            
                    $data = DB::select(DB::expr('COUNT(*)'))
                                    ->from('camera_specs')
                                    ->where($key, 'IS NOT', NULL)
                                    ->and_where($key, $better_symbol, $value)
                                    ->execute()
                                    ->as_array();
                    $absolute_better = $data[0]['COUNT(*)']; 
                        
                    $data = DB::select(DB::expr('COUNT(*)'))
                                    ->from('camera_specs')
                                    ->where($key, 'IS NOT', NULL)
                                    ->and_where($key, $worse_symbol, $value)
                                    ->execute()
                                    ->as_array();
                    $absolute_worse = $data[0]['COUNT(*)'];
                        
                    $data = DB::select(DB::expr('COUNT(*)'))
                                    ->from('camera_specs')
                                    ->where($key, 'IS NOT', NULL)
                                    ->and_where($key, '=', $value)
                                    ->and_where('id', '!=', $camera['id'])
                                    ->execute()
                                    ->as_array();
                    $absolute_same = $data[0]['COUNT(*)'];
                    
                    DB::update('camera_specs_compare')
                            ->set(array('count_better' => $better, 'count_same' => $same, 'count_worse' => $worse,
                                    'absolute_count_better' => $absolute_better, 'absolute_count_same' => $absolute_same,
                                    'absolute_count_worse' => $absolute_worse))
                            ->where('camera_type', '=', $camera_type)
                            ->and_where('spec', '=', $key)
                            ->and_where('value', '=', $value)
                            ->execute();
                }
                   
            }       
        }    
    }
    
    public function process_score_data()
    {
        $specs = ORM::factory('specs_camera')->get_available_specs(true);
        
        $cameras = ORM::factory('specs_camera')
                ->find_all();
        foreach ($cameras as $camera) {
            $specs_data = ORM::factory('specs_camera')->get_specs_full_data($camera, true);
            
            $absolute_score = 0;
            foreach ($specs as $key => $spec) { 
                if (isset($spec['weight']) && $spec['weight']) {
                    $weight = $spec['weight'];
                    if (isset($specs_data[$key]['compare']['value']) && $specs_data[$key]['compare']['value']) {
                        $value = $specs_data[$key]['compare']['absolute_value'];
                        $absolute_score += $value * $weight;     
                    }    
                }    
            
            }
            DB::update('models')
                    ->set(array('specs_score' => $absolute_score))
                    ->where('id', '=', $camera->id)
                    ->execute();
        }
        /*$tmp_cameras = $cameras; 
        $cameras = array();
        foreach ($tmp_cameras as $camera) {
            $cameras[$camera->id] = $camera;    
        }
        
        $models = ORM::factory('model')
                ->where('category_id', '=', 396)
                ->order_by('specs_score', 'DESC')
                ->find_all();      
        
        $all_type_score = 1;
        $same_type_score = array(
            0 => 1, 1 => 1, 2 => 1,
            3 => 1, 4 => 1, 5 => 1,
            6 => 1, 7 => 1, 8 => 1,
        );
        foreach ($models as $model) {
            $model->all_type_score  = $all_type_score;
            $model->same_type_score = isset($same_type_score[$cameras[$model->id]->camera_type]) ? $same_type_score[$cameras[$model->id]->camera_type] : 0;
            $model->save();
            
            $all_type_score++;
            if (isset($same_type_score[$cameras[$model->id]->camera_type])) {
                $same_type_score[$cameras[$model->id]->camera_type]++;
            }    
        }   */
    }
    
    public function process_data()
    {   
        //$this->_add_empty_records();
        //$this->_process_sensor_data(); 
        //$this->_process_lens_data();
        //$this->_process_screen_data(); 
        //$this->_process_size_body_data(); 
        //$this->_process_viewfinder_data();
        //$this->_process_video_data(); 
        //$this->_process_performance_data();
        //$this->_process_af_data();
        //$this->_process_flash_data();
        //$this->_process_storage_data();
        $this->_process_features_data();
    }
    
    protected function _add_empty_records()
    {
        $cameras = DB::select('id')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array(); 
        foreach ($cameras as $camera) {
            try {
                $spec = new Model_Specs_Camera();
                $spec->id = $camera['id'];
                $spec->save();
            } catch (Database_Exception $e) {
                if (strstr($e->getMessage(), 'Duplicate entry') !== false) {
                    continue;
                }
                die($e->getMessage());
            }
        }  
    }
    
    protected function _process_sensor_data()
    {
        // Возвращаем 2 значения - в дюймах и в мм
        function get_physical_size($size) {
            $types = array(
                array(
                    'inch' => 'Полноразмерная',
                    'mm'   => '36 x 24',    
                ),
                array(
                    'inch' => 'APS-C',
                    'mm'   => '23.7 x 15.6',   
                ),
                array(
                    'inch' => 'APS-C',
                    'mm'   => '23.5 x 15.7',   
                ),
                array(
                    'inch' => 'APS-C',
                    'mm'   => '23.6 x 15.8',   
                ),
                array(
                    'inch' => 'APS-C',
                    'mm'   => '22.3 x 14.9',   
                ),
                array(
                    'inch' => '4/3"',
                    'mm'   => '18.3 x 13.0',    
                ),
                array(
                    'inch' => '1"',
                    'mm'   => '12.8 x 9.6',   
                ),
                array(
                    'inch' => '2/3"',
                    'mm'   => '8.8 x 6.6',    
                ),
                array(
                    'inch' => '1/1.8"',
                    'mm'   => '7.2 x 5.3',   
                ),
                array(
                    'inch' => '1/2"',
                    'mm'   => '6.4 x 4.8',   
                ),
                array(
                    'inch' => '1/2.3"',
                    'mm'   => '6.16 x 4.62',   
                ),
                array(
                    'inch' => '1/2.33"',
                    'mm'   => '6,16 x 4.62',    
                ),
                array(
                    'inch' => '1/2.5"',
                    'mm'   => '5.8 x 4.3',  
                ),
                array(
                    'inch' => '1/2.7"',
                    'mm'   => '5.4 x 4.0',   
                ),
                array(
                    'inch' => '1/3"',
                    'mm'   => '4.8 x 3.6',   
                ),
                array(
                    'inch' => '1/1.7"',
                    'mm'   => '7 x 5',    
                ),

            );    
            
            if (strstr($size, '35 мм') !== false) {  // Сразу отсекаем первый тип
                return array(
                    'inch' => $types[0]['inch'],
                    'mm'   => $types[0]['mm'],    
                );
            }
            
            $result = array(
                'inch' => null,
                'mm'   => null,
            );
            if (strstr($size, '"') !== false) {     // В дюймах, например 1/2.3"
                foreach ($types as $type) {
                    if ($type['inch'] == $size) {
                        return $type;    
                    }    
                }
                $result['inch'] = $size;
                return $result;           
            } else if (strstr($size, 'x') !== false) {  // В мм, например 23.6 x 15.8 мм
                $size = str_replace(' мм', '', $size);  
                foreach ($types as $type) {
                    if ($type['mm'] == $size) {
                        return $type;    
                    }    
                }
                $result['mm'] = $size;
                return $result;     
            } else {
                return $result;
            }
        }
        function get_physical_diagonal($size) {
            if (!$size) {
                return null;
            }        
            list($width, $height) = explode(' x ', $size);
            $diagonal = sqrt($width*$width + $height*$height);
            return $diagonal;
        }
        function get_max_resolution($resolution) {
            if (!$resolution) {
                return null;    
            }
            list($width, $height) = explode(' x ', $resolution);
            return $width*$height;  
        }
        function get_sensitivity($sensitivity) {
            if (!$sensitivity) {
                return null;
            }
            $params = explode(',', $sensitivity);
            $sensitivity = $params[0];
            $sensitivity = trim(str_replace(' ISO', '', $sensitivity));
            $parts = explode(' - ', $sensitivity);
            if (count($parts) == 1) {
                return $parts[0];
            } else if (count($parts) == 2) {
                return array(
                    'min' => $parts[0],
                    'max' => $parts[1],
                );    
            }
            return null;   
        }
        function get_boost_sensitivity($sensitivity) {
            if (!$sensitivity) {
                return null;
            }
            if (strstr($sensitivity, 'ISO102400') !== false) {
                return 102400;    
            } else if (strstr($sensitivity, 'ISO51200') !== false) {
                return 51200;    
            } else if (strstr($sensitivity, 'ISO25600') !== false) {
                return 25600;    
            } else if (strstr($sensitivity, 'ISO12800') !== false) {
                return 12800;    
            } else if (strstr($sensitivity, 'ISO6400') !== false) {
                return 6400;    
            }
            return null;
        }
        function get_auto_sensitivity($sensitivity) {
            if (!$sensitivity) {
                return null;    
            }
            if (strstr($sensitivity, 'Auto ISO') !== false) {
                return 1;    
            }
            return 0;   
        }
        
        //http://www.64bita.ru/matrix.html
        $cameras = DB::select('id', 'matrix_type', 'physical_size', 'crop_factor', 'total_pixels', 'effective_pixels',
                        'max_resolution', 'color_depth', 'sensitivity', 'sensor_cleaning')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {           
            $spec = ORM::factory('specs_camera', $camera['id']); 
            if (!$spec->loaded()) {
                throw new Model_Exception('Запись не загрузили');
            } 
            // ---  
            $matrix_type = $camera['matrix_type'];
            if ($matrix_type) {
                if ($matrix_type == 'СCD') {    // Первая буква на русском =)
                    $matrix_type = 'CCD';    
                }
                if ($matrix_type == 'Live MOS') {
                    $matrix_type = 1;  
                } else {
                    $types = Model_Main::reverse_array(self::$_matrix_types);
                    $matrix_type = $types[$matrix_type];
                }    
            }   
            $spec->matrix_type = $matrix_type;
            
            // ---
            $physical_size = get_physical_size($camera['physical_size']);
            $size = '';
            if ($physical_size['inch']) {
                $size = $physical_size['inch'];
                if ($physical_size['mm']) {
                    $size .= ' - '.$physical_size['mm'];    
                }    
            } else {
                if ($physical_size['mm']) {
                    $size = $physical_size['mm'];    
                }
            }
            if (!$size) {
                $size = null;
            }
            $spec->physical_size_visible = $size;
            $spec->physical_size         = get_physical_diagonal($physical_size['mm']);     // больше - лучше
            
            // ---
            $spec->crop_factor = $camera['crop_factor'];                                    // меньше - лучше
            
            // ---
            $total_pixels = null;
            if ($camera['total_pixels']) {
                $total_pixels = str_replace(' млн', '', $camera['total_pixels']);    
            }
            $spec->total_pixels = $total_pixels;
            
            // ---
            $effective_pixels = null;
            if ($camera['effective_pixels']) {
                $effective_pixels = str_replace(' млн', '', $camera['effective_pixels']);    
            }
            $spec->effective_pixels = $effective_pixels;
            
            // ---
            $resolution = null;
            if ($camera['max_resolution']) {
                $resolution = str_replace(' (интерполированное)', '', $camera['max_resolution']);   
            }
            $spec->max_resolution_visible = $resolution;
            $spec->max_resolution         = get_max_resolution($resolution);
            
            // ---
            $color_depth = null;
            if ($camera['color_depth']) {
                $color_depth = str_replace(' бит', '', $camera['color_depth']);        
            }
            $spec->color_depth = $color_depth;
            
            // ---
            $sensitivity = get_sensitivity($camera['sensitivity']);
            $visible = null;
            if ($sensitivity) {
                if (!is_array($sensitivity)) {
                    $visible = $sensitivity;    
                } else if ($sensitivity['min'] && $sensitivity['max']) {
                    $visible = implode(' - ', $sensitivity);
                    $sensitivity = $sensitivity['max'];    
                }
            }
            $spec->sensitivity_visible = $visible;
            $spec->sensitivity         = $sensitivity;
            $spec->boost_sensitivity   = get_boost_sensitivity($camera['sensitivity']);
            $spec->auto_sensitivity    = get_auto_sensitivity($camera['sensitivity']);
            
            // ---
            $spec->sensor_cleaning = $camera['sensor_cleaning'] ? 1 : 0;
            
            $spec->save();
        }      
    }
    
    protected function _process_lens_data()
    {
        function get_min_focal_length($value) {
            if (!$value) {
                return null;
            }
            $value = str_replace(' мм', '', $value);
            if (strstr($value, '-') !== false) {
                list($min, $max) = explode(' - ', $value);
                return $min;    
            }
            return $value;    
        }
        function get_max_focal_length($value) {
            if (!$value) {
                return null;
            }
            $value = str_replace(' мм', '', $value);
            if (strstr($value, '-') !== false) {
                list($min, $max) = explode(' - ', $value);
                return $max;    
            }
            return $value;    
        }
        function get_min_diaphragm($value) {
            if (!$value) {
                return null;
            } 
            $value = str_replace('F', '', $value);
            if (strstr($value, '-') !== false) {
                list($min, $max) = explode(' - ', $value);
                return $min;    
            }
            return null;  
        }
        function get_max_diaphragm($value) {
            if (!$value) {
                return null;
            }  
            $value = str_replace('F', '', $value);
            if (strstr($value, '-') !== false) {
                list($min, $max) = explode(' - ', $value);
                return $max;    
            }
            return null; 
        }
        function get_aspherical_lens($fetures) {
            if (!$fetures) {
                return null;    
            }
            if (strstr($fetures, 'асферические линзы') !== false) {
                return 1;    
            }
            return 0;   
        }
        function get_low_dispersion_lenses($fetures) {
            if (!$fetures) {
                return null;    
            }
            if (strstr($fetures, 'низкодисперсные линзы') !== false) {
                return 1;    
            }
            return 0;   
        }
        
        $cameras = DB::select('id', 'lens_name', 'focal_length', 'optical_zoom', 'diaphragm', 'optical_elements_count', 'optical_element_groups_count',
                'features')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {           
            $spec = ORM::factory('specs_camera', $camera['id']); 
            if (!$spec->loaded()) {
                throw new Model_Exception('Запись не загрузили');
            } 
            // ---
            $spec->lens_name = $camera['lens_name'];
            
            // ---
            $spec->min_focal_length = get_min_focal_length($camera['focal_length']);    // меньше - лучше
            $spec->max_focal_length = get_max_focal_length($camera['focal_length']);    // больше - лучше   
            
            // ---
            $optical_zoom = null;
            if ($camera['optical_zoom']) {
                $optical_zoom = str_replace('x', '', $camera['optical_zoom']);          // больше - лучше
            }
            $spec->optical_zoom = $optical_zoom;
            
            // ---
            $spec->min_diaphragm = get_min_diaphragm($camera['diaphragm']);             // меньше - лучше  
            $spec->max_diaphragm = get_max_diaphragm($camera['diaphragm']);             // больше - лучше  
            
            // ---
            $spec->optical_elements_count = $camera['optical_elements_count'];          // больше - лучше
            $spec->optical_element_groups_count = $camera['optical_element_groups_count'];  // больше - лучше
            
            // ---
            $spec->aspherical_lens       = get_aspherical_lens($camera['features']);    // хорошо
            $spec->low_dispersion_lenses = get_low_dispersion_lenses($camera['features']);  // тоже
            
            $spec->save();
        }
    }
    
    protected function _process_screen_data()
    {
        function get_lcd($screen) {
            $result = array(
                'resolution' => null,
                'size'       => null, 
            );
            if (!$screen) {
                return $result;
            } 
            if (strstr($screen, ',')) {
                list($resolution, $size) = explode(', ', $screen);
                $result = array(
                    'resolution' => str_replace(' пикселов', '', $resolution),
                    'size'       => str_replace(' дюйма', '', $size), 
                ); 
                return $result;   
            } else if (strstr($screen, 'пикселов') !== false) {
                $result['resolution'] = str_replace(' пикселов', '', $screen);
                return $result;   
            } else if (strstr($screen, 'дюйма') !== false) {
                $result['size'] = str_replace(' дюйма', '', $screen);
                return $result;   
            }
            return $result;
        }
        function get_lcd_type($type) {
            $result = array(
                'touch_screen' => null,
                'flips_out'    => null, 
            );  
            if (!$type) {
                return $result;    
            }
            $result['touch_screen'] = 0;    
            if (strstr($type, 'сенсорный') !== false) {
                $result['touch_screen'] = 1;    
            } 
            $result['flips_out'] = 0; 
            if (strstr($type, 'поворотный') !== false) {
                $result['flips_out'] = 1;    
            }
            return $result;
        }
        
        $cameras = DB::select('id', 'lcd_Screen', 'lcd_type')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {           
            $spec = ORM::factory('specs_camera', $camera['id']); 
            if (!$spec->loaded()) {
                throw new Model_Exception('Запись не загрузили');
            } 
            // ---
            $lcd = get_lcd($camera['lcd_Screen']);
            $spec->lcd_size       = $lcd['size'];
            $spec->lcd_resolution = $lcd['resolution'];
            
            // ---
            $lcd = get_lcd_type($camera['lcd_type']);
            $spec->lcd_touch_screen = $lcd['touch_screen'];
            $spec->lcd_flips_out    = $lcd['flips_out'];
            
            
            $spec->save();
        }
    }
    
    protected function _process_size_body_data()
    {
        function get_size($visible) {
            if (!$visible) {
                return null;   
            } 
            list($w, $h, $d) = explode('x', $visible);
            return $w*$h*$d;   
        }
        function get_weight($weight) {
            $result = array(
                'netto'  => null,
                'brutto' => null,
            );
            if (!$weight) {
                return $result;   
            }
            $parts = explode(',', $weight);
            if (count($parts) == 4) {
                if (strstr($parts[1], 'без элементов питания') !== false) {
                    $result['netto'] = str_replace(' г', '', $parts[0]);   
                } else if (strstr($parts[1], 'с элементами питания') !== false) {
                    $result['brutto'] = str_replace(' г', '', $parts[0]);   
                }
                if (strstr($parts[3], 'с элементами питания') !== false) {
                    $result['brutto'] = str_replace(' г', '', $parts[2]);   
                } else if (strstr($parts[3], 'без элементов питания') !== false) {
                    $result['netto'] = str_replace(' г', '', $parts[2]);   
                }
                return $result;
            } else if (count($parts) == 2) {
                if (strstr($parts[1], 'без элементов питания') !== false) {
                    $result['netto'] = str_replace(' г', '', $parts[0]);   
                } else if (strstr($parts[1], 'с элементами питания') !== false) {
                    $result['brutto'] = str_replace(' г', '', $parts[0]);
                } 
                return $result;   
            }
            return $result;
        }
        
        $cameras = DB::select('id', 'size', 'weight', 'body_material', 'additional_features', 'change_lenses')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {           
            $spec = ORM::factory('specs_camera', $camera['id']); 
            if (!$spec->loaded()) {
                throw new Model_Exception('Запись не загрузили');
            } 
            // ---
            $visible = null;
            if ($camera['size']) {
                $visible = str_replace(' мм', '', $camera['size']);    
            }
            if (strstr($visible, ', без объектива')) {
                $visible = str_replace(', без объектива', '', $visible); 
                $spec->size_wout_lens_visible = $visible;
                $spec->size_wout_lens         = get_size($visible);   
            } else {
                $spec->size_visible = $visible;
                $spec->size         = get_size($visible);
            }
            
            // ---
            $weight = get_weight($camera['weight']);
            $spec->weight_netto  = $weight['netto'];
            $spec->weight_brutto = $weight['brutto'];      
            
            // ---
            $body_material = null;
            if ($camera['body_material']) {
                if (strstr($camera['body_material'], 'металл/пластик') !== false) {
                    $body_material = 1; // !!!   
                } else if (strstr($camera['body_material'], 'пластик') !== false) {
                    $body_material = 0;
                } else if (strstr($camera['body_material'], 'металл') !== false) {
                    $body_material = 2;   
                }    
            }
            $spec->body_material = $body_material;
            
            // ---
            $waterproof_case = null;
            if ($camera['additional_features']) {
                $waterproof_case = 0;
                if (strstr($camera['additional_features'], 'влагонепроницаемый корпус') !== false) {
                    $waterproof_case = 1;   
                }   
            }
            $spec->waterproof_case = $waterproof_case;
            
            // ---
            $change_lenses = null;
            if ($camera['change_lenses']) {
                $change_lenses = 1;        
            }
            $spec->change_lenses = $change_lenses;
            
            
            $spec->save();
        }   
    }
    
    protected function _process_viewfinder_data()
    {
        function get_viewfinder($viewfinder) {
            if (!$viewfinder) {
                return null;
            }
            $types = Model_Specs_camera::$_viewfinder_types; 
            $types = Model_Main::reverse_array($types);
            if (isset($types[$viewfinder])) {
                return $types[$viewfinder];
            }
            return null;  
        }
        function get_viewfinder_sight($viewfinder) {
            if (!$viewfinder) {
                return null;
            }
            return str_replace('%', '', $viewfinder); 
        }
        
        $cameras = DB::select('id', 'viewfinder', 'viewfinder_sight')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {           
            $spec = ORM::factory('specs_camera', $camera['id']); 
            if (!$spec->loaded()) {
                throw new Model_Exception('Запись не загрузили');
            } 
            // ---
            $spec->viewfinder       = get_viewfinder($camera['viewfinder']);
            $spec->viewfinder_sight = get_viewfinder_sight($camera['viewfinder_sight']);
            
            $spec->save();
        }   
    }
    
    protected function _process_video_data()
    {
        function get_max_resolution($resolution) {
            if (!$resolution) {
                return null;    
            }
            try {
                list($width, $height) = explode('x', $resolution);          // english x
            } catch (Exception $e) {
                if (strstr($e->getMessage(), 'Undefined offset') !== false) {
                    list($width, $height) = explode('х', $resolution);      // русский х
                } else {  
                    throw new Exception($e->getMessage()); 
                } 
            }
            return $width*$height;  
        }
        
        function _get_max_hd_video($rate) {
            $result = $rate;
            if (strstr($rate, '/') !== false) {
                list($a, $b) = explode('/', $rate);
                $result = $b;   
            }
            return $result;   
        }
        function get_max_hd_video($rate) {
            $result = array(
                '1280_720'  => null,
                '1920_1080' => null,  
            );
            if (!$rate) {
                return $result;    
            } 
            if (strstr($rate, 'кадров/с при разрешениях 1280x720 и 1920x1080') !== false) {
                $rate = str_replace(' кадров/с при разрешениях 1280x720 и 1920x1080', '', $rate); 
                $result['1280_720']  = _get_max_hd_video($rate);
                $result['1920_1080'] = _get_max_hd_video($rate);  
            } else {
                $parts = array();
                if (strstr($rate, ', ') !== false) {
                    $parts = explode(', ', $rate);  
                } else {
                    $parts[] = $rate;   
                }
                
                foreach ($parts as $part) {
                    if (strstr($part, 'кадров/с при разрешении 1280x720') !== false) {
                        $part = str_replace(' кадров/с при разрешении 1280x720', '', $part);
                        $result['1280_720']  = _get_max_hd_video($part);
                    }
                    if (strstr($part, 'кадров/с при разрешении 1920x1080') !== false) {
                        $part = str_replace(' кадров/с при разрешении 1920x1080', '', $part);
                        $result['1920_1080']  = _get_max_hd_video($part);
                    } 
                }   
            }
            return $result;
        }
        function get_isset_or_not($field) {
            $result = null;
            if ($field) {
                if (strstr($field, 'есть') !== false) {
                    $result = 1;    
                } else if (strstr($field, 'нет') !== false) {
                    $result = 0;   
                }   
            }
            return $result;    
        }
        
        $cameras = DB::select('id', 'video_recording', 'video_recording_format', 'video_codecs', 'max_video_resolution', 'max_video_frame_rate',
                    'max_hd_video_frame_rate', 'duration_video_recording', 'video_electronic_stabilization', 'video_optical_zoom', 'sound record', 'audio_comments_record')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {           
            $spec = ORM::factory('specs_camera', $camera['id']); 
            if (!$spec->loaded()) {
                throw new Model_Exception('Запись не загрузили');
            } 
            // ---
            $spec->video_recording = get_isset_or_not($camera['video_recording']);
            
            // ---
            $spec->video_recording_format = $camera['video_recording_format'];
            
            // ---
            $spec->video_codecs = $camera['video_codecs'];
            
            // ---
            $spec->max_video_resolution_visible = $camera['max_video_resolution'];
            $spec->max_video_resolution         = get_max_resolution($camera['max_video_resolution']);
            
            // ---
            $max_video_frame_rate = $camera['max_video_frame_rate'];
            if ($max_video_frame_rate) {
                $max_video_frame_rate = str_replace(' кадров/с', '', $max_video_frame_rate);   
            }
            $spec->max_video_frame_rate = $max_video_frame_rate;
            
            // ---
            $max_hd_video                 = get_max_hd_video($camera['max_hd_video_frame_rate']);
            $spec->max_hd_video_1280_720  = $max_hd_video['1280_720'];
            $spec->max_hd_video_1920_1080 = $max_hd_video['1920_1080']; 
            
            // ---
            $spec->duration_video_recording = $camera['duration_video_recording'];
            
            // ---
            $spec->video_electronic_stabilization = get_isset_or_not($camera['video_electronic_stabilization']);
            
            // ---
            $spec->video_optical_zoom    = get_isset_or_not($camera['video_optical_zoom']); 
            
            
            $spec->save();
        }  
    }
    
    protected function _process_performance_data()
    {
        function get_max_set_shots($set) {
            $result = array(
                'jpeg' => null,
                'raw'  => null,   
            );
            if (!$set) {
                return $result;   
            }
            $parts = array();
            if (strstr($set, ', ') !== false) {
                $parts = explode(', ', $set);   
            } else {
                $parts[] = $set;  
            }
            foreach ($parts as $part) {
                if (strstr($part, ' для JPEG') !== false) {
                    $result['jpeg'] = str_replace(' для JPEG', '', $part);   
                }  
                if (strstr($part, ' для RAW') !== false) {
                    $result['raw'] = str_replace(' для RAW', '', $part);   
                }  
            }
            return $result;
        }
        function get_battery_capacity($capacity) {
            $result = null;
            if (!$capacity) {
                return $result;  
            }
            $parts = array();
            if (strstr($capacity, ' или ') !== false) {
                $parts = explode(' или ', $capacity);   
            } else {
                $parts[] = $capacity;
            }
            foreach ($parts as $part) {
                if (strstr($part, ' фотографий') !== false) {
                    $result = str_replace(' фотографий', '', $part);       
                }  
            }
            return $result;
        }
        
        $cameras = DB::select('id', 'shooting_speed', 'max_set_shots', 'battery_capacity')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {           
            $spec = ORM::factory('specs_camera', $camera['id']); 
            if (!$spec->loaded()) {
                throw new Model_Exception('Запись не загрузили');
            } 
            // ---
            $speed = $camera['shooting_speed'];
            if ($speed) {
                $speed = str_replace(' кадр./сек', '', $speed);    
            }
            $spec->shooting_speed = $speed;
            
            // ---
            $set = get_max_set_shots($camera['max_set_shots']);
            $spec->max_set_shots_jpeg = $set['jpeg'];
            $spec->max_set_shots_raw  = $set['raw'];
            
            // ---
            $spec->battery_capacity = get_battery_capacity($camera['battery_capacity']);            
            
            $spec->save();
        }   
    }
    
    protected function _process_af_data()
    {
        function get_isset_or_not($field) {
            $result = null;
            if ($field) {
                if (strstr($field, 'есть') !== false) {
                    $result = 1;    
                } else if (strstr($field, 'нет') !== false) {
                    $result = 0;   
                }   
            }
            return $result;    
        }
        
        $cameras = DB::select('id', 'af_assist', 'manual_focus', 'af_adjustment', 'face_focus', 'min_shooting_distance')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {           
            $spec = ORM::factory('specs_camera', $camera['id']); 
            if (!$spec->loaded()) {
                throw new Model_Exception('Запись не загрузили');
            } 
            // ---
            $spec->af_assist = get_isset_or_not($camera['af_assist']);
            
            // ---
            $spec->manual_focus = get_isset_or_not($camera['manual_focus']);
            
            // ---
            $spec->af_adjustment = get_isset_or_not($camera['af_adjustment']);
            
            // ---
            $spec->face_focus = get_isset_or_not($camera['face_focus']);
            
            // ---
            $min_shooting_distance = null;
            if ($camera['min_shooting_distance']) {
                $min_shooting_distance = str_replace(' м', '', $camera['min_shooting_distance']);                
            }
            $spec->min_shooting_distance = $min_shooting_distance;
            
            $spec->save();
        }  
    }
    
    protected function _process_flash_data()
    {
        function get_max_flash_distance($flash) {
            if (!$flash) {
                return null;
            }
            $parts = explode(', ', $flash);
            foreach ($parts as $part) {
                if (strstr($part, 'до ') !== false) {
                    $distance = str_replace(array('до ', ' м'), '', $part); 
                    return $distance;
                }  
            }
            return null;
        }
        function get_flash_mode($flash, $modes) {
            if (!$flash) {
                return null;
            } 
            $parts = explode(', ', $flash);
            foreach ($parts as $part) {
                if (array_key_exists($part, $modes)) { 
                    return $modes[$part];
                }  
            }
            return null; 
        }
        function get_flash_chock($flash) {
            if (!$flash) {
                return null;
            } 
            if (strstr($flash, 'башмак') !== false) {
                return 1;
            }
            return 0;  
        }
        function get_flash_bracketing($flash) {
            if (!$flash) {
                return null;
            } 
            if (strstr($flash, 'брекетинг') !== false) {
                return 1;
            }
            return 0;
        }
        function get_flash_red_eye_reduction($flash) {
            if (!$flash) {
                return null;
            } 
            if (strstr($flash, 'подавление эффекта красных глаз') !== false) {
                return 1;
            }
            return 0;  
        }
        function get_flash_synccontact($flash) {
            if (!$flash) {
                return null;
            } 
            if (strstr($flash, 'синхроконтакт') !== false) {
                return 1;
            }
            return 0;   
        }
        
        $cameras = DB::select('id', 'flash')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {           
            $spec = ORM::factory('specs_camera', $camera['id']); 
            if (!$spec->loaded()) {
                throw new Model_Exception('Запись не загрузили');
            } 
            // ---
            $spec->max_flash_distance = get_max_flash_distance($camera['flash']);
            
            // ---
            $spec->flash_mode = get_flash_mode($camera['flash'], Model_Main::reverse_array(self::$_flash_modes));
            
            // ---
            $spec->flash_chock = get_flash_chock($camera['flash']);
            
            // ---
            $spec->flash_bracketing = get_flash_bracketing($camera['flash']);
            
            // ---
            $spec->flash_red_eye_reduction = get_flash_red_eye_reduction($camera['flash']);
            
            // ---
            $spec->flash_synccontact = get_flash_synccontact($camera['flash']);
            
            $spec->save();
        }  
    }
    
    protected function _process_storage_data()
    {
        $cameras = DB::select('id', 'card_type', 'builtin_memory', 'image_formats')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {           
            $spec = ORM::factory('specs_camera', $camera['id']); 
            if (!$spec->loaded()) {
                throw new Model_Exception('Запись не загрузили');
            } 
            // ---
            $spec->card_type = $camera['card_type'];
            
            // ---
            $builtin_memory = null;
            if ($camera['builtin_memory']) {
                $builtin_memory = str_replace(' Мб', '', $camera['builtin_memory']);    
            }
            $spec->builtin_memory = $builtin_memory;
            
            // ---
            $spec->image_formats = $camera['image_formats'];
            
            $spec->save();
            
        }    
    }
    
    protected function _process_features_data()
    {        
        $cameras = DB::select('id', 'image_stabilizer', 'additional_features')
                ->from($this->_tmp_table_name)
                ->execute()
                ->as_array();
        foreach ($cameras as $camera) {           
            $spec = ORM::factory('specs_camera', $camera['id']); 
            if (!$spec->loaded()) {
                throw new Model_Exception('Запись не загрузили');
            } 
            // ---
            $image_stabilizer = null;
            foreach (self::$_image_stabilizer_modes as $key => $value) {
                if (strstr($camera['image_stabilizer'], $value) !== false) {
                    $image_stabilizer = $key;
                    break;   
                }    
            }
            $spec->image_stabilizer = $image_stabilizer;
            
            // ---
            $hdr_support = null;
            if ($camera['additional_features']) {
                if (strstr($camera['additional_features'], 'cъемка HDR') !== false) {
                    $hdr_support = 1;    
                }    
            }
            $spec->hdr_support = $hdr_support;
            
            // ---
            $gps = null;
            if ($camera['additional_features']) {
                if (strstr($camera['additional_features'], 'GPS') !== false) {
                    $gps = 1;    
                }   
            }
            $spec->gps = $gps;
            
            
            
            $spec->save(); 
        }  
    }
}